package com.app.gamev2.game

import android.content.Context
import android.graphics.PointF
import android.util.DisplayMetrics
import android.view.WindowManager
import androidx.core.content.ContextCompat
import com.app.gamev2.objects.Bucket
import com.app.gamev2.objects.Platform
import com.app.gamev2.objects.Player
import com.app.gamev2.utils.CollisionUtils
import com.app.gamev2.utils.VibrationUtils
import java.util.*

/**
 * 游戏核心控制器，管理游戏的主要逻辑
 */
class GameManager(
    private val context: Context,
    private val player: Player
) {
    // 游戏状态
    var gameState = GameConfig.GameState.READY
        private set
    // 平台列表
    private val platforms = mutableListOf<Platform>()
    // 氦气罐列表
    private val buckets = mutableListOf<Bucket>()
    // 随机数生成器
    private val random = Random()
    // 屏幕尺寸
    private val screenWidth: Int
    private val screenHeight: Int
    // 当前高度
    var currentHeight = 0f
        private set
    // 上次平台Y坐标
    private var lastPlatformY = 0f
    // 屏幕密度（用于dp转px）
    private val density: Float
    // 玩家当前所在平台索引
    private var currentPlatformIndex: Int = -1
    // 平台生成冷却时间
    private var platformGenerationCooldown: Float = 0f
    // 平台生成冷却阈值
    private val PLATFORM_GENERATION_COOLDOWN = 1.0f // 秒
    
    // dp转px的辅助方法
    private fun dpToPx(dp: Float): Float {
        return dp * density
    }

    init {
        // 获取屏幕尺寸和密度
        val windowManager = ContextCompat.getSystemService(context, WindowManager::class.java)
        val displayMetrics = DisplayMetrics()
        windowManager?.defaultDisplay?.getMetrics(displayMetrics)
        screenWidth = displayMetrics.widthPixels
        screenHeight = displayMetrics.heightPixels
        density = displayMetrics.density

        // 设置玩家尺寸（60dp）
        player.size = dpToPx(60f)

        // 初始化游戏
        initGame()
        
        // 将玩家放置在初始平台上
        placePlayerOnInitialPlatform()
    }
    
    /**
     * 将玩家放置在初始平台上，确保不会掉落
     */
    private fun placePlayerOnInitialPlatform() {
        // 找到屏幕上可见的最低平台
        val initialPlatform = findVisibleLowestPlatform()
        
        // 将玩家放置在找到的平台上
        if (initialPlatform != null) {
            // 随机设置玩家在平台上的X位置（确保在平台范围内）
            val minX = initialPlatform.position.x + player.size / 2
            val maxX = initialPlatform.position.x + initialPlatform.width - player.size / 2
            val randomX = minX + random.nextFloat() * (maxX - minX)
            player.position.x = randomX
            player.targetX = randomX // 确保targetX与position.x一致，防止自动移动
            
            // 确保玩家精确地站在平台上
            // 计算角色位置：平台顶部 - 角色半径（确保角色底部与平台顶部接触）
            // 移除额外偏移，使气球底部刚好接触平台顶部，避免视觉空隙
            player.position.y = initialPlatform.position.y - player.size / 2
            player.land() // 确保玩家处于站立状态
        }
    }

    /**
     * 初始化游戏
     */
    private fun initGame() {
        // 清空平台和氦气罐列表
        platforms.clear()
        buckets.clear()

        // 重置高度
        currentHeight = 0f

        // 初始化上次平台Y坐标为屏幕高度（从底部开始生成平台）
        lastPlatformY = screenHeight.toFloat()

        // 首先创建一个明显的初始平台，确保玩家一定会站在上面
        val initialPlatformWidth = dpToPx(150f) // 较大的初始平台，确保足够的站立空间
        val initialPlatformX = (screenWidth - initialPlatformWidth) / 2f // 居中放置
        val initialPlatformY = screenHeight - dpToPx(200f) // 放置在屏幕下方，避开按钮区域
        
        // 创建初始平台
        val initialPlatform = Platform(
            initialPlatformX,
            initialPlatformY,
            initialPlatformWidth,
            dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat())
        )
        platforms.add(initialPlatform)
        lastPlatformY = initialPlatformY
        
        // 预先生成几个较低的平台（在初始平台下方）
        for (i in 0 until 2) {
            // 随机生成平台宽度（70-200dp）
            val platformWidth = dpToPx(
                random.nextInt(
                    (GameConfig.PLATFORM_MAX_WIDTH_DP - GameConfig.PLATFORM_MIN_WIDTH_DP + 1)
                ) + GameConfig.PLATFORM_MIN_WIDTH_DP.toFloat()
            )

            // 随机生成平台水平位置
            val platformX = random.nextInt((screenWidth - platformWidth).toInt())

            // 较小的垂直间距（20-60dp）
            val platformSpacing = dpToPx(
                random.nextInt(41) + 20f // 20-60dp
            )

            // 计算平台Y坐标（在初始平台下方）
            lastPlatformY += platformSpacing

            // 创建平台
            val platform = Platform(
                platformX.toFloat(),
                lastPlatformY,
                platformWidth,
                dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat())
            )
            platforms.add(platform)
        }
        
        // 重置lastPlatformY为初始平台的Y坐标，准备向上生成平台
        lastPlatformY = initialPlatformY

        // 在初始平台上方生成3个普通间距的平台
        for (i in 0 until 3) {
            // 随机生成平台宽度（70-200dp）
            val platformWidth = dpToPx(
                random.nextInt(
                    (GameConfig.PLATFORM_MAX_WIDTH_DP - GameConfig.PLATFORM_MIN_WIDTH_DP + 1)
                ) + GameConfig.PLATFORM_MIN_WIDTH_DP.toFloat()
            )

            // 随机生成平台水平位置
            val platformX = random.nextInt((screenWidth - platformWidth).toInt())

            // 随机生成平台垂直间距（50-150dp）
            val platformSpacing = dpToPx(
                random.nextInt(
                    (GameConfig.PLATFORM_MAX_SPACING_DP - GameConfig.PLATFORM_MIN_SPACING_DP + 1)
                ) + GameConfig.PLATFORM_MIN_SPACING_DP.toFloat()
            )

            // 计算平台Y坐标（在初始平台上方）
            lastPlatformY -= platformSpacing

            // 创建平台
            val platform = Platform(
                platformX.toFloat(),
                lastPlatformY,
                platformWidth,
                dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat())
            )
            platforms.add(platform)
        }

        // 设置游戏状态为准备
        gameState = GameConfig.GameState.READY
    }
    
    /**
     * 查找屏幕上可见的最低平台（Y坐标最大的平台）
     * @return 找到的平台，如果没有找到则返回null
     */
    private fun findVisibleLowestPlatform(): Platform? {
        // 计算按钮区域的高度（从布局文件中获取，底部操作区高度为80dp，跳跃按钮高度为100dp并带有-10dp的底部边距）
        val buttonAreaHeight = dpToPx(110f) // 确保足够的空间避开按钮
        
        // 首先检查是否有特殊标记的初始平台
        // 在当前实现中，初始平台是第一个添加的平台，且位置在屏幕下方
        val initialPlatform = platforms.firstOrNull()
        if (initialPlatform != null && 
            initialPlatform.position.y + initialPlatform.height >= 0 && 
            initialPlatform.position.y <= screenHeight - buttonAreaHeight) {
            return initialPlatform
        }
        
        // 筛选出屏幕可见且位于按钮区域上方的平台
        val visiblePlatforms = platforms.filter { platform ->
            // 平台至少有一部分在屏幕内，并且平台底部高于按钮区域顶部
            platform.position.y + platform.height >= 0 && 
            platform.position.y <= screenHeight &&
            platform.position.y + platform.height <= screenHeight - buttonAreaHeight
        }
        
        if (visiblePlatforms.isEmpty()) {
            // 如果没有找到合适的平台，尝试返回任何可见的平台
            val anyVisiblePlatforms = platforms.filter { platform ->
                platform.position.y + platform.height >= 0 && platform.position.y <= screenHeight
            }
            if (anyVisiblePlatforms.isEmpty()) {
                return null
            }
            
            // 找到Y坐标最大的平台（最低的平台）
            val lowestAnyPlatforms = anyVisiblePlatforms.groupBy { it.position.y }
                .maxByOrNull { it.key }?.value
            return lowestAnyPlatforms?.random()
        }
        
        // 找到Y坐标最大的平台（最低的平台）
        val lowestPlatforms = visiblePlatforms.groupBy { it.position.y }
            .maxByOrNull { it.key }?.value
        
        // 如果有多个Y坐标相同的最低平台，随机选一个
        return lowestPlatforms?.random()
    }

    /**
     * 开始游戏
     */
    fun startGame() {
        // 在开始游戏前，重新确保玩家站在平台上
        placePlayerOnInitialPlatform()
        
        // 设置游戏状态为进行中
        gameState = GameConfig.GameState.PLAYING
    }

    /**
     * 重置游戏
     */
    fun resetGame() {
        // 重置玩家状态
        player.setBucketLevel(1)
        player.isJumping = false
        player.isFloating = false
        player.setJumpCount(0)
        player.jumpPower = 0f
        player.horizontalVelocity = 0f
        player.verticalVelocity = 0f
        
        // 初始化游戏
        initGame()
        
        // 将玩家放置在初始平台上
        placePlayerOnInitialPlatform()
    }

    /**
     * 更新游戏状态
     * @param deltaTime 时间间隔
     */
    fun update(deltaTime: Float) {
        if (gameState != GameConfig.GameState.PLAYING) {
            return
        }

        // 1. 首先检查玩家是否应该漂浮（在平台上）
        checkCollisions()
        
        // 2. 然后根据当前状态更新物理（如果isFloating为true，则不受重力影响）
        player.updatePhysics(deltaTime)
        
        // 3. 最后检查玩家是否仍然在平台上（仅在物理更新后检查，避免错误取消漂浮状态）
        checkIfPlayerStillOnPlatform()

        // 更新平台状态
        updatePlatforms(deltaTime)

        // 检查胜利/失败条件
        checkGameConditions()

        // 确保玩家在屏幕范围内
        constrainPlayerPosition()

        // 视差滚动背景（这里只更新高度，实际绘制时需要处理）
        updateParallax(deltaTime)
        
        // 记录玩家当前所在平台信息
        if (currentPlatformIndex >= 0 && currentPlatformIndex < platforms.size) {
            android.util.Log.d("GameManager", "[调试] 玩家当前在平台 #${currentPlatformIndex + 1}，Y位置: ${platforms[currentPlatformIndex].position.y}")
        }
    }
    
    /**
     * 检查玩家是否仍然站在平台上
     * 如果玩家不再站在任何平台上，取消漂浮状态，使气球受重力影响
     */
    private fun checkIfPlayerStillOnPlatform() {
        // 如果玩家不在漂浮状态或正在跳跃中，无需检查
        if (!player.isFloating || player.isJumping) {
            return
        }
        
        // 计算玩家底部中心位置
        val playerBottomCenterY = player.position.y + player.size / 2
        
        // 计算可接受的垂直距离范围
        val verticalRange = dpToPx(10f)
        
        // 遍历所有平台，寻找玩家是否站在某个平台上
        val standingOnPlatform = platforms.any { platform ->
            // 垂直方向：玩家底部中心与平台顶部的距离在可接受范围内
            val verticalDistance = Math.abs(playerBottomCenterY - platform.position.y)
            val verticalCondition = verticalDistance <= verticalRange
            
            // 水平方向：玩家底部与平台有重叠
            val playerLeftEdge = player.position.x - player.size / 4
            val playerRightEdge = player.position.x + player.size / 4
            val platformLeftEdge = platform.position.x
            val platformRightEdge = platform.position.x + platform.width
            val horizontalCondition = playerLeftEdge < platformRightEdge && playerRightEdge > platformLeftEdge
            
            // 同时满足垂直和水平条件
            verticalCondition && horizontalCondition
        }
        
        // 如果没有站在平台上，设置为非漂浮状态
        if (!standingOnPlatform) {
            player.isFloating = false
        } else {
            // 持续校准位置，防止因微小移动产生间隙
            // 确保气球底部始终精确接触平台顶部
            player.position.y = platforms.find { platform ->
                val verticalDistance = Math.abs(playerBottomCenterY - platform.position.y)
                val verticalCondition = verticalDistance <= verticalRange
                val playerLeftEdge = player.position.x - player.size / 4
                val playerRightEdge = player.position.x + player.size / 4
                val platformLeftEdge = platform.position.x
                val platformRightEdge = platform.position.x + platform.width
                val horizontalCondition = playerLeftEdge < platformRightEdge && playerRightEdge > platformLeftEdge
                verticalCondition && horizontalCondition
            }?.position?.y?.minus(player.size / 2) ?: player.position.y
            
            // 关键修复：无论如何都显式设置垂直速度为0，防止因物理计算产生的微小速度
            player.verticalVelocity = 0f
            
            // 确保isFloating状态为true，isJumping状态为false
            player.isFloating = true
            player.isJumping = false
        }
    }

    /**
     * 根据当前高度动态生成平台
     */
    private fun generatePlatformForCurrentLevel(): Platform {
        android.util.Log.d("GameManager", "[调试] 开始生成平台")
        
        // 随机生成平台宽度（70-200dp）
        val platformWidth = dpToPx(
            random.nextInt(
                (GameConfig.PLATFORM_MAX_WIDTH_DP - GameConfig.PLATFORM_MIN_WIDTH_DP + 1)
            ) + GameConfig.PLATFORM_MIN_WIDTH_DP.toFloat()
        )
        android.util.Log.d("GameManager", "[调试] 生成的平台宽度: $platformWidth px")

        // 随机生成平台水平位置
        val platformX = random.nextInt((screenWidth - platformWidth).toInt())
        android.util.Log.d("GameManager", "[调试] 生成的平台X位置: $platformX px")

        // 随机生成平台垂直间距（50-150dp），避免过小间距导致平台堆积
        val platformSpacing = dpToPx(
            random.nextInt(
                (GameConfig.PLATFORM_MAX_SPACING_DP - GameConfig.PLATFORM_MIN_SPACING_DP + 1)
            ) + GameConfig.PLATFORM_MIN_SPACING_DP.toFloat()
        )
        android.util.Log.d("GameManager", "[调试] 生成的平台间距: $platformSpacing px")

        // 计算平台Y坐标，允许平台在屏幕顶部之外生成，这样它们可以随着玩家上升而逐渐出现
        lastPlatformY -= platformSpacing
        
        android.util.Log.d("GameManager", "[调试] 平台位置: ($platformX, $lastPlatformY)，宽度: $platformWidth px")

        // 计算是否生成氦气罐
        val randomFloat = random.nextFloat()
        val hasBucket = when {
            player.bucketLevel <= 2 -> randomFloat < 0.45f // 1-2级: 45%概率
            player.bucketLevel <= 4 -> randomFloat < 0.55f // 3-4级: 55%概率
            else -> randomFloat < 0.6f // 5级以上: 60%概率
        }
        android.util.Log.d("GameManager", "[调试] 氦气罐检查随机值: $randomFloat, 是否生成氦气罐: $hasBucket")
        
        // 创建并返回平台对象
        if (hasBucket) {
            // 根据玩家等级动态调整1~10级氦气罐的生成概率
            android.util.Log.d("GameManager", "[调试] 生成带氦气罐的平台")
            val bucketLevel = generateBucketLevelByPlayerLevel()
            
            return Platform(
                platformX.toFloat(),
                lastPlatformY,
                platformWidth,
                dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat()),
                bucketLevel
            )
        } else {
            android.util.Log.d("GameManager", "[调试] 生成不带氦气罐的平台")
            return Platform(
                platformX.toFloat(),
                lastPlatformY,
                platformWidth,
                dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat())
            )
        }
    }

    /**
     * 生成指定数量的平台
     * @param count 平台数量
     */
    private fun generatePlatforms(count: Int) {
        android.util.Log.d("GameManager", "[调试] 开始为玩家等级 ${player.bucketLevel} 生成 $count 个平台")
        
        // 确保有足够的起始平台数据
        if (platforms.isEmpty()) {
            lastPlatformY = screenHeight.toFloat()
        }
        
        // 确保平台之间的间距合理
        val basePlatformSpacing = dpToPx(GameConfig.PLATFORM_HEIGHT_DP.toFloat()) + dpToPx(GameConfig.PLATFORM_MIN_SPACING_DP.toFloat())
        
        for (i in 0 until count) {
            android.util.Log.d("GameManager", "[调试] 正在生成平台 #${i+1}/$count")
            
            // 生成平台并添加到列表
            val platform = generatePlatformForCurrentLevel()
            
            platforms.add(platform)
            
            android.util.Log.d("GameManager", "[调试] 平台 #${i+1} 已添加到列表，位置: (${platform.position.x}, ${platform.position.y})，宽度: ${platform.width} px，hasBucket: ${platform.hasBucket}")

            // 如果平台带氦气罐，创建氦气罐对象
            if (platform.hasBucket) {
                val bucketX = platform.position.x + platform.width / 2
                val bucketY = platform.position.y - dpToPx(20f)
                android.util.Log.d("GameManager", "[调试] 为平台 #${i+1} 创建氦气罐，等级: ${platform.bucketLevel}，位置: ($bucketX, $bucketY)")
                
                val bucket = Bucket(
                    bucketX,
                    bucketY, // 氦气罐位于平台上方
                    platform.bucketLevel,
                    dpToPx(30f) // 氦气罐尺寸
                )
                buckets.add(bucket)
                
                android.util.Log.d("GameManager", "[调试] 氦气罐已创建并添加到列表: 等级 ${bucket.level}，位置 (${bucket.position.x}, ${bucket.position.y})，玩家当前等级: ${player.bucketLevel}")
            }
            
            // 确保合理的间距
            lastPlatformY -= (basePlatformSpacing + random.nextInt(50))
        }
        
        android.util.Log.d("GameManager", "[调试] 平台生成完成。总平台数: ${platforms.size}，总氦气罐数: ${buckets.size}")
    }

    /**
     * 更新玩家当前所在平台索引
     */
    private fun updateCurrentPlatformIndex() {
        // 计算玩家底部中心位置
        val playerBottomCenterY = player.position.y + player.size / 2
        val playerLeft = player.position.x - player.size / 2
        val playerRight = player.position.x + player.size / 2
        
        // 遍历所有平台，找到玩家当前站在的平台
        for (i in platforms.indices) {
            val platform = platforms[i]
            val platformTop = platform.position.y
            val platformBottom = platform.position.y + platform.height
            val platformLeft = platform.position.x
            val platformRight = platform.position.x + platform.width
            
            // 检查玩家是否站在这个平台上
            // 垂直方向：玩家底部接近平台顶部
            // 水平方向：玩家与平台有重叠
            val verticalCondition = Math.abs(playerBottomCenterY - platformTop) < dpToPx(10f)
            val horizontalCondition = playerLeft < platformRight && playerRight > platformLeft
            
            if (verticalCondition && horizontalCondition) {
                currentPlatformIndex = i
                // 记录玩家当前所在平台的详细信息
                android.util.Log.d("GameManager", "[调试] 更新玩家当前平台信息 - 索引: $i, 编号: ${i+1}, 位置: (${platform.position.x}, ${platform.position.y}), 玩家位置: (${player.position.x}, ${player.position.y})${if(platform.hasBucket) ", 带${platform.bucketLevel}级氦气罐" else ""}")
                return
            }
        }
        
        // 如果没有找到平台，设置索引为-1
        currentPlatformIndex = -1
        android.util.Log.d("GameManager", "[调试] 未找到玩家所在平台，索引重置为 -1，玩家位置: (${player.position.x}, ${player.position.y})")
    }
    
    /**
     * 获取玩家当前所在平台编号（从1开始）
     */
    fun getCurrentPlatformNumber(): Int {
        val platformNumber = if (currentPlatformIndex >= 0) currentPlatformIndex + 1 else 0
        android.util.Log.d("GameManager", "[调试] 获取玩家当前平台编号: $platformNumber (索引: $currentPlatformIndex)")
        return platformNumber
    }
    
    /**
     * 检查碰撞
     */
    private fun checkCollisions() {
        // 优化碰撞检测：首先检查玩家是否正在下落（垂直速度≥0）
        if (player.verticalVelocity >= 0) {
            // 遍历所有平台，找到玩家可以着陆的平台
            val landingPlatform = platforms.find { platform ->
                CollisionUtils.checkPlayerLandingOnPlatform(player, platform)
            }
            
            if (landingPlatform != null) {
                // 玩家成功落在平台上，确保着陆状态被正确激活
                player.land()
                
                // 调整玩家位置，使其精确落在平台顶部
                player.position.y = landingPlatform.position.y - player.size / 2
                
                // 额外安全措施：显式设置垂直速度为0，防止因速度不为零导致的滑落
                player.verticalVelocity = 0f
                
                // 检查是否需要合并氦气罐
                if (landingPlatform.hasBucket) {
                    // 查找对应平台上的氦气罐
                    val bucket = buckets.find { bucket ->
                        CollisionUtils.checkPlayerBucketCollision(player, bucket)
                    }
                    
                    if (bucket != null) {
                        // 检查氦气罐等级是否与玩家当前等级匹配
                        if (bucket.level == player.bucketLevel) {
                            // 成功合并氦气罐，提升等级
                            if (player.mergeBucket()) {
                                // 合并成功，移除该氦气罐
                                buckets.remove(bucket)
                                landingPlatform.hasBucket = false
                                
                                // 震动反馈
                                VibrationUtils.vibrateForMerge(context)
                            }
                        } else {
                            // 等级不匹配，移除该氦气罐
                            buckets.remove(bucket)
                            landingPlatform.hasBucket = false
                            
                            // 震动反馈
                            VibrationUtils.vibrateForLose(context)
                        }
                    }
                }
            }
        }
    }

    /**
     * 根据玩家等级动态生成氦气罐等级
     * 实现以玩家当前等级为中心的权重分布：当前等级40%，±1等级各20%，±2等级各10%
     * 限制等级范围在1~maxLevel（10级）内
     */
    private fun generateBucketLevelByPlayerLevel(): Int {
        val playerLevel = player.bucketLevel
        val maxLevel = GameConfig.WIN_BUCKET_LEVEL // 10级是最高等级
        
        // 确保玩家等级在有效范围内
        val effectivePlayerLevel = playerLevel.coerceIn(1, maxLevel)
        
        // 记录生成氦气罐时的玩家等级，用于调试
        android.util.Log.d("GameManager", "[调试] 为玩家等级 $effectivePlayerLevel 生成氦气罐等级，最高等级: $maxLevel")
        
        // 定义等级权重分布：以玩家当前等级为中心的正态分布
        val levelWeights = mutableListOf<Pair<Int, Int>>()
        
        // 当前等级：40%权重
        levelWeights.add(effectivePlayerLevel to 40)
        android.util.Log.d("GameManager", "[调试] 添加等级 $effectivePlayerLevel，权重 40")
        
        // ±1 等级：各20%权重
        if (effectivePlayerLevel - 1 >= 1) {
            levelWeights.add(effectivePlayerLevel - 1 to 20) // 低1级：20%
            android.util.Log.d("GameManager", "[调试] 添加等级 ${effectivePlayerLevel - 1}，权重 20")
        }
        
        if (effectivePlayerLevel + 1 <= maxLevel) {
            levelWeights.add(effectivePlayerLevel + 1 to 20) // 高1级：20%
            android.util.Log.d("GameManager", "[调试] 添加等级 ${effectivePlayerLevel + 1}，权重 20")
        }
        
        // ±2 等级：各10%权重
        if (effectivePlayerLevel - 2 >= 1) {
            levelWeights.add(effectivePlayerLevel - 2 to 10) // 低2级：10%
            android.util.Log.d("GameManager", "[调试] 添加等级 ${effectivePlayerLevel - 2}，权重 10")
        }
        
        if (effectivePlayerLevel + 2 <= maxLevel) {
            levelWeights.add(effectivePlayerLevel + 2 to 10) // 高2级：10%
            android.util.Log.d("GameManager", "[调试] 添加等级 ${effectivePlayerLevel + 2}，权重 10")
        }
        
        // 记录权重分布，用于调试
        val weightsInfo = levelWeights.joinToString(", ") { "${it.first}级:${it.second}%" }
        android.util.Log.d("GameManager", "[调试] 玩家等级 $effectivePlayerLevel 的最终等级权重分布: $weightsInfo")
        
        // 根据权重选择等级
        val bucketLevel = selectLevelByWeight(levelWeights)
        
        // 记录生成的氦气罐等级，用于调试
        android.util.Log.d("GameManager", "[调试] 生成的氦气罐等级: $bucketLevel，玩家等级: $effectivePlayerLevel")
        
        return bucketLevel
    }
    
    /**
     * 根据权重随机选择等级
     * 使用更可靠的实现方式确保权重分布正确
     */
    private fun selectLevelByWeight(levelWeights: List<Pair<Int, Int>>): Int {
        // 计算总权重
        val totalWeight = levelWeights.sumOf { it.second }
        android.util.Log.d("GameManager", "[调试] 总权重: $totalWeight")
        
        if (totalWeight <= 0 || levelWeights.isEmpty()) {
            android.util.Log.e("GameManager", "[调试] 无效权重: totalWeight=$totalWeight, 权重数量=${levelWeights.size}")
            return 1 // 兜底返回最低等级
        }
        
        // 生成随机数
        val randomValue = random.nextInt(totalWeight)
        android.util.Log.d("GameManager", "[调试] 生成的随机值: $randomValue")
        
        // 遍历权重区间，找到对应的等级
        var currentWeight = 0
        android.util.Log.d("GameManager", "[调试] 开始计算权重区间")
        
        for ((level, weight) in levelWeights) {
            val startWeight = currentWeight
            currentWeight += weight
            val endWeight = currentWeight
            android.util.Log.d("GameManager", "[调试] 检查等级 $level: 权重 $weight，区间 [$startWeight, $endWeight)")
            
            if (randomValue < currentWeight) {
                android.util.Log.d("GameManager", "[调试] 选中等级 $level (随机值 $randomValue 落在区间 [$startWeight, $endWeight) 内)")
                return level
            }
        }
        
        // 兜底返回列表中的第一个等级（最有可能的是当前等级）
        val fallbackLevel = levelWeights.first().first
        android.util.Log.d("GameManager", "[调试] 回退到第一个等级: $fallbackLevel")
        return fallbackLevel
    }               
    
    /**
     * 更新平台状态
     * @param deltaTime 时间间隔
     */
    private fun updatePlatforms(deltaTime: Float) {
        android.util.Log.d("GameManager", "[调试] 开始更新平台。当前平台数: ${platforms.size}，当前氦气罐数: ${buckets.size}")
        
        // 更新平台生成冷却时间
        platformGenerationCooldown -= deltaTime
        
        // 记录移除前的数量，用于计算移除了多少
        val initialPlatformCount = platforms.size
        val initialBucketCount = buckets.size
        
        // 遍历平台，更新状态并移除已消失在玩家视野底部的平台
        val iterator = platforms.iterator()
        val platformsToRemove = mutableListOf<Platform>()
        
        while (iterator.hasNext()) {
            val platform = iterator.next()
            if (platform.update(deltaTime)) {
                android.util.Log.d("GameManager", "[调试] 标记位置 ${platform.position.y} 的平台为移除对象，hasBucket: ${platform.hasBucket}")
                platformsToRemove.add(platform)
                iterator.remove()
                android.util.Log.d("GameManager", "[调试] 平台已移除，当前平台数: ${platforms.size}")
            } else if (platform.position.y > screenHeight + 300) {  // 当平台完全移出屏幕底部时移除（300像素的缓冲区）
                android.util.Log.d("GameManager", "[调试] 强制移除超出屏幕底部的平台，位置: ${platform.position.y}")
                platformsToRemove.add(platform)
                iterator.remove()
                android.util.Log.d("GameManager", "[调试] 平台已移除，当前平台数: ${platforms.size}")
            }
        }
        
        // 同时移除对应的氦气罐
        val bucketIterator = buckets.iterator()
        while (bucketIterator.hasNext()) {
            val bucket = bucketIterator.next()
            
            // 先检查bucket.position是否为null
            val bucketPos = bucket.position
            if (bucketPos != null) {
                // 检查是否超出屏幕底部很远
                if (bucketPos.y > screenHeight + 300) {
                    bucketIterator.remove()
                    android.util.Log.d("GameManager", "[调试] 氦气罐已移除，当前氦气罐数: ${buckets.size}")
                    continue
                }
                
                // 检查氦气罐是否属于被移除的平台
                var shouldRemove = false
                for (platform in platformsToRemove) {
                    if (platform.hasBucket) {
                        val platformPos = platform.position
                        if (platformPos != null) {
                            val platformCenterX = platformPos.x + platform.width / 2
                            val expectedBucketY = platformPos.y - dpToPx(20f)
                            
                            if (Math.abs(bucketPos.x - platformCenterX) < 1 &&
                                Math.abs(bucketPos.y - expectedBucketY) < 1) {
                                shouldRemove = true
                                break
                            }
                        }
                    }
                }
                
                if (shouldRemove) {
                    bucketIterator.remove()
                    android.util.Log.d("GameManager", "[调试] 氦气罐已移除，当前氦气罐数: ${buckets.size}")
                }
            }
        }
        
        // 记录本次更新后的平台和氦气罐数量
        android.util.Log.d("GameManager", "[调试] 平台更新完成。移除了 ${initialPlatformCount - platforms.size} 个平台，移除了 ${initialBucketCount - buckets.size} 个氦气罐。当前平台数: ${platforms.size}，当前氦气罐数: ${buckets.size}")

        // 检查是否需要生成新平台（当最高位置的平台接近屏幕顶部时生成新平台）
        // 添加冷却机制，避免生成过快
        val highestPlatform = platforms.maxByOrNull { it.position.y }
        if (platformGenerationCooldown <= 0 && (highestPlatform == null || highestPlatform.position.y > -screenHeight * 0.3f)) {
            android.util.Log.d("GameManager", "[调试] 满足平台生成条件。最高平台Y坐标: ${highestPlatform?.position?.y ?: "无"}")
            
            // 重置冷却时间
            platformGenerationCooldown = PLATFORM_GENERATION_COOLDOWN
            
            // 减少每次生成的平台数量，避免生成过快
            val platformsToGenerate = when {
                player.bucketLevel < 3 -> {
                    android.util.Log.d("GameManager", "[调试] 玩家等级 ${player.bucketLevel}: 生成1个平台")
                    1      // 1-2级生成1个平台
                }
                player.bucketLevel < 5 -> {
                    android.util.Log.d("GameManager", "[调试] 玩家等级 ${player.bucketLevel}: 生成2个平台")
                    2      // 3-4级每次生成2个平台
                }
                else -> {
                    android.util.Log.d("GameManager", "[调试] 玩家等级 ${player.bucketLevel}: 生成3个平台")
                    3      // 5级及以上每次生成3个平台
                }
            }
            generatePlatforms(platformsToGenerate)
        } else {
            android.util.Log.d("GameManager", "[调试] 不需要生成新平台")
        }
        
        // 更新玩家当前所在平台
        updateCurrentPlatformIndex()
        
        android.util.Log.d("GameManager", "[调试] 平台更新完成。平台数: ${platforms.size}，氦气罐数: ${buckets.size}")
    }

    /**
     * 检查游戏胜利/失败条件
     */
    private fun checkGameConditions() {
        // 失败条件：玩家掉落出屏幕底部
        if (player.position.y - player.size / 2 > screenHeight + 100) {
            gameState = GameConfig.GameState.LOSE
        }

        // 胜利条件：同时满足氦气罐等级达到Lv.3和高度达到100m
        if (player.bucketLevel >= GameConfig.WIN_BUCKET_LEVEL && currentHeight >= GameConfig.WIN_HEIGHT_M) {
            gameState = GameConfig.GameState.WIN
        }
    }

    /**
     * 限制玩家位置在屏幕范围内
     */
    private fun constrainPlayerPosition() {
        // 左右边界限制
        if (player.position.x - player.size / 2 < 0) {
            player.position.x = player.size / 2
        } else if (player.position.x + player.size / 2 > screenWidth) {
            player.position.x = screenWidth - player.size / 2
        }
    }

    /**
     * 更新视差效果和高度计算
     */
    private fun updateParallax(deltaTime: Float) {
        // 这里简化处理，实际游戏中需要实现更复杂的视差效果
        // 当玩家向上移动且位于屏幕上半部分时，移动平台实现视差效果
        if (player.verticalVelocity < 0) {
            val heightIncrease = -player.verticalVelocity * 0.01f * deltaTime // 简单转换像素到米，考虑时间间隔
            currentHeight += heightIncrease
            
            // 调整平台移动距离系数，使其能够更快地跟随角色移动
            // 增加移动系数从0.1到0.8，使平台移动更灵敏
            val moveDistance = -player.verticalVelocity * 0.8f * deltaTime 
            
            // 限制移动距离，防止平台被过快地推到负值区域
            val maxMoveDistance = screenHeight * 0.5f // 每次最多移动屏幕高度的一半
            val clampedMoveDistance = moveDistance.coerceAtMost(maxMoveDistance)
            
            for (platform in platforms) {
                platform.position.y += clampedMoveDistance
            }
            for (bucket in buckets) {
                bucket.position.y += clampedMoveDistance
            }
        }
        
        // 额外处理：当玩家明显高于屏幕中线时，强制移动平台
        // 确保玩家不会移出屏幕视野
        if (player.position.y < screenHeight * 0.3f) {
            // 计算需要移动的距离，使玩家保持在屏幕合适位置
            val forceMoveDistance = (screenHeight * 0.3f - player.position.y) * 0.2f * deltaTime
            player.position.y += forceMoveDistance
            
            // 同时移动所有平台和氦气罐，保持相对位置
            for (platform in platforms) {
                platform.position.y += forceMoveDistance
            }
            for (bucket in buckets) {
                bucket.position.y += forceMoveDistance
            }
        }
        
        // 不再限制平台的最小Y坐标，允许平台在屏幕上方生成
        // 当平台下行消失在玩家视野后，就会在updatePlatforms中被销毁
        
        // 移除超出屏幕底部过远的平台和氦气罐，防止内存泄漏
        val initialPlatformCount = platforms.size
        val initialBucketCount = buckets.size
        
        val iterator = platforms.iterator()
        while (iterator.hasNext()) {
            val platform = iterator.next()
            if (platform.position.y > screenHeight + 500) { // 超出屏幕底部500像素时移除
                iterator.remove()
                android.util.Log.d("GameManager", "[调试] 移除超出屏幕底部过远的平台，位置: ${platform.position.y}，当前平台数: ${platforms.size}")
            }
        }
        
        val bucketIterator = buckets.iterator()
        while (bucketIterator.hasNext()) {
            val bucket = bucketIterator.next()
            if (bucket.position.y > screenHeight + 500) { // 超出屏幕底部500像素时移除
                bucketIterator.remove()
                android.util.Log.d("GameManager", "[调试] 移除超出屏幕底部过远的氦气罐，位置: ${bucket.position.y}，当前氦气罐数: ${buckets.size}")
            }
        }
        
        // 记录移除的平台和氦气罐数量
        android.util.Log.d("GameManager", "[调试] 清理完成。移除了 ${initialPlatformCount - platforms.size} 个平台，移除了 ${initialBucketCount - buckets.size} 个氦气罐。当前平台数: ${platforms.size}，当前氦气罐数: ${buckets.size}")
    }

    /**
     * 获取当前所有平台
     */
    fun getPlatforms(): List<Platform> {
        return platforms.toList()
    }

    /**
     * 获取当前所有氦气罐
     */
    fun getBuckets(): List<Bucket> {
        return buckets.toList()
    }

    /**
     * 查找玩家上方最近的平台高度
     * @param playerY 玩家当前的Y坐标
     * @return 最近平台的Y坐标（如果没有找到，则返回一个较高的值）
     */
    fun findNearestPlatformHeight(playerY: Float): Float {
        var nearestPlatformY = Float.MAX_VALUE
        var minDistance = Float.MAX_VALUE

        // 遍历所有平台，找出玩家上方最近的平台
        for (platform in platforms) {
            // 只考虑玩家上方的平台（平台Y坐标小于玩家Y坐标）
            if (platform.position.y < playerY) {
                // 计算平台中心到玩家中心的水平距离
                val horizontalDistance = Math.abs(platform.position.x + platform.width / 2 - player.position.x)
                
                // 计算垂直距离
                val verticalDistance = playerY - platform.position.y
                
                // 如果水平距离在可跳跃范围内，且垂直距离是目前找到的最小
                if (horizontalDistance <= platform.width / 2 + player.size / 2 && verticalDistance < minDistance) {
                    minDistance = verticalDistance
                    nearestPlatformY = platform.position.y
                }
            }
        }

        // 如果没有找到合适的平台，返回一个默认的较高值
        return if (nearestPlatformY == Float.MAX_VALUE) {
            playerY - 100f // 默认向上跳100像素
        } else {
            nearestPlatformY
        }
    }

}